{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#导入需要的库\n",
    "from xgboost import XGBClassifier\n",
    "import xgboost as xgb\n",
    "\n",
    "import pandas as pd \n",
    "import numpy as np\n",
    "\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.model_selection import StratifiedKFold\n",
    "\n",
    "from sklearn.metrics import log_loss\n",
    "\n",
    "from matplotlib import pyplot\n",
    "import seaborn as sns\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#导入需要的文件\n",
    "dpath = \"./data/\"\n",
    "train = pd.read_csv(dpath+\"RentListingInquries_FE_train.csv\")\n",
    "test = pd.read_csv(dpath+\"RentListingInquries_FE_test.csv\")\n",
    "#train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 49352 entries, 0 to 49351\n",
      "Columns: 228 entries, bathrooms to interest_level\n",
      "dtypes: float64(9), int64(219)\n",
      "memory usage: 85.8 MB\n"
     ]
    }
   ],
   "source": [
    "#查看训练数据信息\n",
    "train.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2    34284\n",
       "1    11229\n",
       "0     3839\n",
       "Name: interest_level, dtype: int64"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#样本分布均匀性\n",
    "train[\"interest_level\"].value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "每类样本分布不是很均匀,总共有三类"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "特征工程网站直接提供，省略，直接进行模型预测"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第一步：初步确立弱学习器的数目"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#获取训练数据\n",
    "y_train=train[\"interest_level\"]\n",
    "X_train=train.drop([\"interest_level\"],axis=1)\n",
    "#将训练特征数据转为矩阵形式\n",
    "X_train=np.array(X_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#不均匀交叉验证设置参数\n",
    "kfold = StratifiedKFold(n_splits=5, shuffle=True, random_state=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#直接调用Xgboost内置的交叉验证，定义模型拟合函数\n",
    "def modelfit(alg,X_train,y_train,cv_folds=None,early_stopping_rounds=10):\n",
    "    xgb_param = alg.get_xgb_params()\n",
    "    xgb_param['num_class'] = 3\n",
    "    \n",
    "    #直接调用xgboost，而非sklarn的wrapper类\n",
    "    xgtrain = xgb.DMatrix(X_train, label = y_train)\n",
    "        \n",
    "    cvresult = xgb.cv(xgb_param, xgtrain, num_boost_round=alg.get_params()['n_estimators'], folds =cv_folds,\n",
    "             metrics='mlogloss', early_stopping_rounds=early_stopping_rounds)\n",
    "  \n",
    "    cvresult.to_csv('1_nestimators.csv', index_label = 'n_estimators')\n",
    "    \n",
    "    #最佳参数n_estimators\n",
    "    n_estimators = cvresult.shape[0]\n",
    "    \n",
    "    # 采用交叉验证得到的最佳参数n_estimators，训练模型\n",
    "    alg.set_params(n_estimators = n_estimators)\n",
    "    alg.fit(X_train, y_train, eval_metric='mlogloss')\n",
    "        \n",
    "    #预测训练集损失:\n",
    "    train_predprob = alg.predict_proba(X_train)\n",
    "    logloss = log_loss(y_train, train_predprob)\n",
    "\n",
    "   #打印模型结果:\n",
    "    print (\"logloss of train :\" )\n",
    "    print(logloss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "logloss of train :\n",
      "0.5220845701932315\n"
     ]
    }
   ],
   "source": [
    "#使用的算法设置\n",
    "xgb1 = XGBClassifier(\n",
    "        learning_rate =0.1,\n",
    "        n_estimators=1000,  #数值大没关系，cv会自动返回合适的n_estimators\n",
    "        max_depth=5,\n",
    "        min_child_weight=1,\n",
    "        gamma=0,\n",
    "        subsample=0.3,\n",
    "        colsample_bytree=0.8,\n",
    "        colsample_bylevel=0.7,\n",
    "        objective= 'multi:softprob',\n",
    "        seed=3)\n",
    "#调用xgboost交叉验证函数\n",
    "modelfit(xgb1, X_train, y_train, cv_folds = kfold)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "h:\\python36\\lib\\site-packages\\ipykernel_launcher.py:1: FutureWarning: from_csv is deprecated. Please use read_csv(...) instead. Note that some of the default arguments are different, so please refer to the documentation for from_csv when changing your function calls\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "220"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cvresult = pd.DataFrame.from_csv('1_nestimators.csv')\n",
    "cvresult.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "初步确认最优弱学习器数目为220"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 交叉验证损失可视化\n",
    "test_means = cvresult['test-mlogloss-mean']\n",
    "test_stds = cvresult['test-mlogloss-std'] \n",
    "        \n",
    "train_means = cvresult['train-mlogloss-mean']\n",
    "train_stds = cvresult['train-mlogloss-std'] \n",
    "\n",
    "x_axis = range(0, cvresult.shape[0])\n",
    "        \n",
    "pyplot.errorbar(x_axis, test_means, yerr=test_stds ,label='Test')\n",
    "pyplot.errorbar(x_axis, train_means, yerr=train_stds ,label='Train')\n",
    "pyplot.title(\"XGBoost n_estimators vs Log Loss\")\n",
    "pyplot.xlabel( 'n_estimators' )\n",
    "pyplot.ylabel( 'Log Loss' )\n",
    "#pyplot.savefig( 'n_estimators1.png' )\n",
    "\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "h:\\python36\\lib\\site-packages\\ipykernel_launcher.py:2: FutureWarning: from_csv is deprecated. Please use read_csv(...) instead. Note that some of the default arguments are different, so please refer to the documentation for from_csv when changing your function calls\n",
      "  \n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAa4AAAGjCAYAAAB0a/FEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAHsAAAB7AB1IKDYgAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3XmclXP/x/HXZ6ZVklCKaCyRJYSQSlmSJSJ0yxrakJDlRpZs/brdFBKVLYQW6ramvSyFSpE93KW6U7Sh0jbf3x/fa86cGec0M52ZM+c65/18PHqcz1znmnOuU2PePt/re30vc84hIiISFlnlfQAiIiIloeASEZFQUXCJiEioKLhERCRUFFySVGbW2MzGBHUFM5thZrWCr7ua2ftmNt3M3jOzRsH2BWY2zcxmmtkjpXAM55hZ7URfp7jvYWanmdm5CbxWJzOrVHpHV6L3nl0Kr5FjZq+VxvGIAFQo7wOQzOKcm2tmv5rZqcBBwCjn3K9mdgrQEjjJObfFzHYD8sJlrXOuFYCZTTazPZ1zSxM4jHOAH4AVCbxGsd/DOfdegq/VCXgN2FTUjmaW5ZzLTfD9RFKagkvKw53A28BW4IRg20VAP+fcFgDn3G/Ab9HfZGbZQEXgLzOrALwI7AmsAy5xzq0yswFAE2AzcCWwFhgTvMTvwPXAacAhZjbJOXd71OtPA+YBRwHznXPXFD5wMzPgceBQYAtwBbB+W+8BfAfs6Jx7wsy+AeYARwAPAu2Ag4HrnHPTg47yKGAHoCtQNdh3XNC1jAFeCP4evnTOXW1mnYDTgR2Bx8zsOmAnwIBTnXN/BcfeBLjCOXeNmWUBHwFtgdfzjt05d3bhz1zo89cAhgevvxy4BMgFRgA7A98A1Z1znYp4ncOAp4JjfNc594CZXR38fW4AHgXm4/+NNwHfO+e6bus1JYM45/RHf5L+B5gO3B/19Thg16C+DfgYuCP4egEwDR8ALwXbLsAHHcClwD34wBoRbGsBPA+cDDwcbMsKHocBh8Y4pmnACUH9IVAjxj5tgfuC+ijgiaLeA98x9Qjq1fiA2Q/4H1AFOBx4JXh+h+DxMODlqOPaMagHAacF9bP4LrVT1N/LfsBrQW0xjn8GkI3/H4Z/xzr2QvvPLvT1LUD3oL4LuDz4t+gbbOsMDCv0PTl5xxS17W18x23AhGCfaXl/5/jTGFdF/b397dj0J3P/6ByXJJ2ZtQW+BVoHQ4Lgf4nvCeCc64cPr12C5/KGChsCVcysBf4X9Kzg+VnA/nG2TQfWmtkLQK9iHN7c4HEJvoMo7GDg3KA76x/sU5L3+Mk59yewFFjgfDe0FKgZPH+TmX2ID8Q9Ynx/rM+YV+Oc+xGYbmbDgAeCLjXaNOBE4B/4Lqmkfz/x/t7nRB9HMezunPvGOeeAz4LXuBV42MyeBxoAo4B6ZvYivrMTATQ5Q5IsmGRwJ3A78ABwX/DUK8A/gyFAiDGMHfySW4sPtB/wHRbB44I42yo65+53zl0OnGpme+OHEQv/Qo+8TfThxnj+W/x5uVbOuZb4oa2SvIeLU5uZ7Yrv6FoAPaLeP/q1Yn1G8MN1mFllYJDzQ3W1gGaF3n8k0BE4zDk3J86xb0us9/8RaBxsO6qI78+z3MwOCoZejwxeY75zrgvwNPBPYItz7jbn3GXAbcHwpojOcUnS3YAfAlsFvG1mV5tZI+fcZDPbH5hqZhuBjUCf4HtqBB1ONv68yjj8L+r2ZvY+/hzXxc6f41oWdCx555+amNmD+J/1/+I7qXHAo2Y2PujuSuIt4CQzmxp8PRxYsK33AH4p5muvDj7fVPxQaZ43gVFmNgr4F/CCmfXGn+N638z2jdq3PvBs8Ev+d3w3E+Gc+9zMjgXGBpti/f1E2yk4T0fwOa4FXjazi4Kv/4UP4I5mNhkfbJtjfLYWUa8zHugNPIMP53eccwvN7AUzy8EPpd4CnG1mPYDKwHtOk04kYP5/YkVEtp+ZVXTObTazzvhzlf8q72OS9KWOSyQOMzsQGFJo84XOueJ2UJnkDTPbEd8p/6O8D0bSmzouEREJFZ3sFBGRUEmZocL27du7nJyc8j4MEREpZwMGDBjjnDsv3vMpE1w5OTn079+/vA9DRETK2YABAxZt63kNFYqISKgouEREJFQUXCIiEioKLhERCRUFl4iIhIqCS0REQkXBJSIioaLgEhGRUFFwiYhIqCi4REQkVBRcIiISKgouEREJFQWXiIiEioJLRERCRcElIiKhklbBtTXXMWDi92zNdeV9KCIiUkbSKrhyneOxyQvIdU4hJiKSptIquKIpxERE0lPaBle0eCGmQBMRCZ+MCK5o0SGmQBMRCZ+MC654FGgiIuGg4CpCcQJNRESSR8G1nRRiIiLlQ8FVChRiIiLJo+AqZQoxEZGypeAqQ3khtnlrriZ4iIiUkrQKrlc++RmA0bMXs3jV+nI+mnwlnbGocBMRiS+tgqvZ/rsCMPmbFbQb9BEAj076nu+X/1GehxVXvEDTcKOISHxpFVz1d60GwOBLj+LTO04GYNW6TVz67KcAXDlsFv8e/x0Ay3//q3wOsoR0TZmISEFpFVzRKmT7j3Zfu0OZcdtJAJzbeE+c87/oW/d/n1b/ngZA/4nf8/YX/wPg9w2bk3+wxaSLpEVE0ji4omVnGQBnHb4Ht57WEIDP7jqFQRc3BmDTllzGfrYUgGP7TqbJA5MAuGnU5wycvACAP/5SoImIpIKMCK5YKmRnccgeNQC47fSGPNupCQDz+5zK69ccD8CRe+/MmqADO7bvZNo94c+bTfjqF1av31QOR10ymhQiIukoY4MrngrZWey9yw4AXHxcfe5qezAAs3qfws1tDgDg+RkLafGvqQD0G/ctHyz4tXwOdjuVdFJISWsRkbKk4CqmapUr0KJBLQBe7XIcs+88BYAsIzLho/tLc3j1Uz8l/8+NW8rnQEtJccJNHZ2IlIftDi4zq2Zmz5nZUDPrGLW9rpk9bmaDzKx5sO3BYFvf0jjoVFClYjYAt57WkDd7NAeg5YG1+GDBbwAc/cAkWv7bd2Wvf7YEgNwM+YWtaf4iUpYS6bjaA6Odc12BdlHbewHrg9deamZ7ARWccz2BisHXaanjMXvz5MVHAvD5Pa156uKjAJjyzQoAGt07gTaPvg/4IcbRsxcDsC7k3dn2iBVim7bkKsxEpEiJBFc9YHFQ50ZtbwQMA3oDdxba7+fg6wgza2Nm/RcuXJjAoaSeyhWyOXiPnQAYFITZB7eeyL/OOwyAKhWzeD/ozpo8OIk2A3yg3fvmV5GZjG99/r/I+bONm7cm9fiTKS/EtuTmarhRRIqUSHAtIT+EsgptXwX8AVQBlkbtt1fwfIRzbrxzrldOTk4ChxIOu1SrxBF77QzADaccwMCOfjr+nDtb0++8RgDUqVElcn7src//xxNTfgDgiPsmRrq1J6f+wJRvfReXd11autG5NBGJJ5HgGgN0MLOngLfMbFiwvT/wEPA0MNg59zOQa2b9ga3OucUxX60UZJlx/ckNyDIrq7coE1UrZdN475oAdGu5H7efcRAAQy87mpHdmgLwae+T6dfeh9uKPzYyZPqPADS+byLtn5wB+OHHZz/8LwCLVq5L+3NqiYSbiITXdgeXc26dc+5K59zVzrmXnXOdgu1fO+c6BX8+CLbd4Zzr5Zy7vZSOO6bsLOPG1geQnWWhDbF4qlepGAm3PmcfEgm09244gZtO9dP0q1bM5r+/rgPg/KdmcuT9EwFo8dBUjnnQX1Tda9Q8XpixEICVf25M244tT2lN94+mABQpX2k7HT5eiKVboNWpUYVm++8GwPWnNOCBcw8FfIc27oYWADzfqQljgouqG+9Vk/lL1wLQ8t/TaPLgZAA6vzCb217/AoB3vljGN8t+BzJ7KDJe0Gm4UqR8pW1wRYsOsXTuyqKZGXVrVAVg/9o7Uq+mv6j60qb1efiCwwH44p5TGRsEWvsj96RhXT+ZZMxnS7jm5c8Af27t1GDiyOXPfco1w/32fuO+Zcj7frjy0/+uYunqDUn6ZOUjOqzibS+Li7kVhiJ/lxHBFU9xurJ0DresLGOvYJWQMxrVpdPxOQA826kJU29uBcDEG0/gkSDoLjmuPm0O3R3ww5LL1vgV9h945+vIbWSOuj9/EkmvUfPoN+5bAGYvXMWaECyTVRYSuZg7Vh3vxqQKQskUGR1c0eJ1ZZnSocVTe6cqNKrn13RsffDutDtiT8APS/Y5+xAA3uzRPLKSyNvXNeff5/sp/0fX34XKFfyP2D1vfsXx/aYAcNvrX/DaHD+5NF2HIstSaQehhjwlbBRcJZDpIVYcdXeuymH1/JT/i47dmxtb+4kj7/Rswby7TwVgv9o7MvHr5QAc328K177ihx+nf++vWdMvyeQriyFPkbKi4NpOmTL5ozRVCrqvLi32ZcilflWRF686hhOCNSCHTv8JgIPvfo/j+vpJI11fnE2fN78CYNyXy/gqmFiiTi35yqKLU9DJ9lBwlYKihhYrZGUpzOJoULs6/2jiVwF7ucuxAHx2V2tGdjsOgLaH70HdGlUAGDVrCT1HzAPgsHsncNIj0wC4Zvhn9B47H4Cp365g5Z8bk/kRJA4FnZQVBVcZyguxShWyMnoSSElVq1yB+rtWA+Dsw/egW8v9AHj+iiZMvqklAFNvbsUTHf1SWqcesjv71doRgKem/0jL4M7Wpz/2ARcO/RiAgVMWRIYnN22JXqFMUoWCTopLwZVkJZ0EoqCLbbcdK0fWgjyn8Z5c2XwfAEZ1a8rcu1sD8H/tG3FNKx96a9Zvjlx43ajP+MjK/b1GzYvclmb07MW8O38ZAB/+8Buf/ncVAKvXb9LQZApK1kzMsqCL2xOj4EpBxQm3kp5jy6Sgq5jtf6yP2GtnTjjAnz+7q+3BDO+cPxT59GVHA37mY3bwd/LRDysZ89lSAB6fvIC+734DQLN+U2jUZwIArftP56yBHwLQYchMOgYdXb9x3/Lyx4sAmLd4DUtWry/zzynFV9YzLktaJ3Jxuyi40kJxAk2TSfJVq1yBA3avDviZj72CJbMevfAInrncB9qobk35z7XNAPjq3jZMv7VVZJ97zvJ3xe55cgO6B8OYVStm89nPawC4fcx8zh3k1488rM8EWgVDl2cN/JDzgnUlb33tCx56z1/j9vFPK1m2Nr0v4A6zsrj8IN7rF+d9U6FjLG8KrjQWHVbxtivQimZm7FqtMgCH7FGDo3N2AaD5/rvR8kDf0V1/SgMe6eAv1B53fQtmBde1Tb6pZWQGZZ+zD+GW0w4E4LB6NaiQ5f/z6zfuW05/9AMAWv17WuS83GOTFkTu2Tbx6+VM/85fLjD359UALFj+B4tW+rUp031BZcmnc4EKLomic26lr1b1yhxYx3d3R9WvyXH77gr4VUjyOr3/XNsscl5uyKVH0b3lvgBs2Lw1cs+24R8vYnBwR4D73voagC4vzqHj0E8Af5PS04IVS2597YvIiiUPvPM1N4/+HIAbR86LzL4c8enPfPzTSsDfyFTn8NJXmM8FxqPgkiKVxTk3KciCv58D61Sn1YG1Abjt9IaRe7a9cOUxvNrVXyIwNhjCnHZLK2bcfhLgb1LaL7hJaaM9a7BDpWwAdq5aicbBPeCO3WcX9q/tZ19+/N9VkXBrfP9EDrlnPAAnPjyNto/7c3g3jfqcRyb4iSvj5i/jkyDo1m/KvDt2Z4rSOhdY1iqU+TtIxskLsTyROpcCIZZXFx7bl5LbpVoldqlWCfALKQMMnPIDPU7aH4A+b33NhcfsDUDfd7/l0X8cAUCD3uP45r7T+OOvzTR5cDJPXXIkGzZtpcOQjzmy/s78stavR/n6Z0sj18cdcd9EdqpSEYALh35Mjaq+fnTS99Su7q+5+3LpWmpXr5yMjy4pIi/Eepy0P9mU7f+oKrgkaYoKtOgLtRVmyZOdZey8gw+9hnV2imy/+FgfgIOn/xSZtNKg9zi+urcNK37fSKuHp3FNq/1YvX4TU75dwcYtucxe5C8huHHkPJb/7oPuyPsnRsLt1AHvR/5tu780h9o7+XB7cuoP7FDZ/zqa9PVydgr2X/jbukj3KJJHwSXlLjrQ1J2lvorZWexZ098yJ+9yg5tHf8E/T2sIwFufL2NiL3+heIPe43i3ZwvWbthM24EfMqDD4WBwzqAZnN6oDiv+8OG2ct0mfl7lLyF4ceYi1m7YDMDFz3zCuo1+aPKIeydQM+gqu700h9129PXD47+jckV/1mPcl8sinecff21mx8r6FZeO9K8qKamkw43RtcIttdSpUYU6wbJdh+xZI7I9704DD733HXe19ZcYvP7ZUl686hjAh95Ht50UqSfceAKr1m/irIEfcUajOqxa52+Tk2XG7xt8uI2evYSVf/rtTR6cHJlRm3dPuQ5DZkY6uC4vzmbLVv+zcskzn5D3U3PJM59EfqZuGDGP6lX8r8lRsxZHbgO0aOW6yPWCW3Pd32bubssva/+KBPPPq9ZHwnXL1lwqZGvaQXEouCRU4gYaCrd0V3unKtTeyQdgXuj1fffbyOzMYTMW8lynJoAPuq/vbcOaDZs5tu9knrioMecMmkHPkxuwfuMWPvphJe2O2IMKWVl8+MNvXNl8H7LM3xT1qub7kOscM39ayfH77crvf/mQ+fCH31gS3DD1wqEfszkIvYPufo+dg6HNpv83mb82+yXFjrx/YuTi9sP6TGDjlq0AnPn4B5Gh0AsGz+TPoKM86O7x5OVfs35TIgF7weCZVAk6yrvf+DLSUY6du5SdglCdt3hNZJ9FK9dRKc0DUMElaae0wi26VtCFT1aWRX7J511w3nz/3SLPtz1sj0h9UsPakfrEqLpDsAD0v977jseDGZ4Neo9j5u0nR+q5d7Vm9fpNnPjwdEZ0PY7KFbJp8dBU3u3Zgq25jlYPT2PqzS2pVCGLI++fxJy7Wke+95M78l/nyz6nsmlrLkfeP4nhnY9l3cYtnPvkDK4/pQEbN2/l459WsfcuO/Bb0FFO/Ho5vwed2x1j5rNhsw/GC4d+HFmP87A+E9g1GFLtMGQmVSv6MOzxymfsUMn/+h83fxn7BbNNw0LBJRmpWOGGgk6KVq1yBaoFw315i0MDkeFRgF13LHqGZeWK2VQOgmWf3fJfJzpsO7fw1/g9++F/efJiv8h0g97jePf6FpE6OlQn39SSles2ctbAj7jupP3ZsGkrM35cyYkNa7N+41bGzl3KyNmL+elXfyF7s+BmrxcMnhkZ/uz20pzIcOld//kyciz3vPFVZJ+BkxewY5XkxUl695MipaS0rmXTNW6STLWqV47MFG3RoBanHlIHgPOOrBe5bGLYFcfw/q0nAjAiuFbwhlMaRBaoPvOwuhxVvyYAObtVIycI1T1rVqVWcMnDnxu38MOKP5P0qdRxiZSJ0uro1LlJMuVNPmkW1eWdfbgfUr37ja+4KrgLQ79x39L1BN/99Z/4PbefcRAAo2YvScpxKrhEUkBJZlEWvjGpQk4yjYJLJIXFC7TSPg8XPWypAJRUp+ASSROJDE8W+F5dTiApTsElkqEKB1287aXR3RWnVhhKcSm4RKTEStzdFacu5zAsPMtT4Zq6FFwikhLKMgzjTWiJrhPpNOOdL4z3XvHqeMGoc5AFKbhEJG3FXMB5G3VJXq/A98Y7X1jM9y0qGEt6DjLROtVZqtz5tFevXq5///7lfRgiIhlra67j8ckL6HlyA4Dtrkuy6HAsZjbAOdcr7vMKLhERSSVFBZeWfBIRkVBRcImISKgouEREJFQUXCIiEioKLhERCRUFl4iIhIqCS0REQkXBJSIioaLgEhGRUFFwiYhIqCi4REQkVBRcIiISKgouEREJFQWXiIiEioJLRERCRcElIiKhouASEZFQUXCJiEioKLhERCRUFFwiIhIqCi4REQkVBZeIiISKgktEREJFwSUiIqGi4BIRkVBRcImISKgouEREJFQUXCIiEioVtvcbzawaMBDYAkx1zr0abO8DNATWAPcBfwLDgJXA7865mxI7ZBERyWSJdFztgdHOua5Au6jtW4BNwEZgNbA78KVzrgtQK4H3ExERSSi46gGLgzo3antf59xlwGTgCmAJcKiZjQV+KvwiZtbGzPovXLgwgUMREZFMkUhwLcGHV4HXcc7lhdgKoDpwJr4zOxeoa2a7RL+Ic268c65XTk5OAociIiKZYrvPcQFjgIFm1g54y8yGOec6mdkdwF7AbkBPwAX7tQAq4YcPRUREtst2B5dzbh1wZdSml4PtfWPsfsH2vo+IiEg0TYcXEZFQUXCJiEioKLhERCRUFFwiIhIqCi4REQkVBZeIiISKgktEREJFwSUiIqGi4BIRkVBRcImISKgouEREJFQUXCIiEioKLhERCRUFl4iIhIqCS0REQkXBJSIioaLgEhGRUFFwiYhIqCi4REQkVBRcIiISKgouEREJFQWXiIiEioJLRERCRcElIiKhouASEZFQUXCJiEioKLhERCRUFFwiIhIqCi4REQkVBZeIiISKgktEREJFwSUiIqGi4BIRkVBRcImISKgouEREJFQUXCIiEioKLhERCRUFl4iIhIqCS0REQkXBJSIioaLgEhGRUFFwiYhIqCi4REQkVBRcIiISKgouEREJFQWXiIiEioJLRERCRcElIiKhouASEZFQUXCJiEioKLhERCRUFFwiIhIqCi4REQkVBZeIiISKgktEREJFwSUiIqGi4BIRkVBRcImISKgouEREJFQUXCIiEioVtvcbzawaMBDYAkx1zr0abO8DNATWAPc55/5nZrcAewOLnHMPJ3zUIiKSsRLpuNoDo51zXYF2Udu3AJuAjcBqM2sMNAVygV8SeD8REZGEgqsesDioc6O293XOXQZMBq4ADgS+d85dD5xuZjtEv4iZtTGz/gsXLkzgUEREJFMkElxL8OFV4HWcc3khtgKoHuy3Ktj2J1Ap+kWcc+Odc71ycnISOBQREckU232OCxgDDDSzdsBbZjbMOdfJzO4A9gJ2A3rihwc7mll/YIVzbk3CRy0iIhlru4PLObcOuDJq08vB9r4xdr92e99HREQkmqbDi4hIqMQMLjM7OHi81MyaJveQRERE4ovXcV1pZocBBwDdkng8IiIi2xQvuPYCrgaGkD8jUEREpNzFm5xxN7Czc26Jmb2ZzAMSERHZlngdV1NgnpmNAk5M4vEkJncrTP0//ygiImkpXnAdBpwMvADsEGef1ONyYXo//ygiImkpXnDtiF+uaUpQh4+6LxGRtBQzuIKFc/sA+wA9knlACflzRX6t7ktEJC3Fu47rMfzq7+cBA5J6RImYP8o/Lv6k4HZ1XyIiaSPeUOEW59z9zrn7gb+SeUAJaRo0hyMuhmn98rer+xIRSRvxgquCmd1lZr2BKsk8oFLRZQos/MDXK38s+Jy6LxGRUIt3jut6/OrvbxAsnhsqO+8NlwWXnz13KswZlv9cdPelEBMRCZ24i+w6575yzn0JXJ7E40mMZUHL2/xjVrbfdskY+HSor5fMLri/hhBFREInvVaHz8qGE2/PDy2AuodD12m+HnkJjIqTw+q+RERC4W/BZWavmtkrwZ9Xgb3L4bgSF919ZQc3Xe4xC2o39PV7t8P6qGUY1X2JiITC34LLOdfROXdR8Kejc65teRxYwmJ1X5WrQ6vbfb3xd3jyWF/nbin4veq+RERSVnoNFZZEu0Fw0UhfP3NKwWu/1H2JiKSszAiu6GHDaHsc6R+bXAWjLvP1pnUF91H3JSKSUuKtnPGmmY0zs/fMbLSZnZXsAytVsYYNozW+FLp/5OuhrWDxp/nPqfsSEUkp8TquuUBb4AzgK6BN0o6orMXrvqrt5h9PuAVGXuzrv9YW3Efdl4hIuYsXXA2B3YHaQAPgt6QdUVmL7r5ihdhhHaDr+75+8jj4/NX853TxsohIuYsXXPcANwI3A/cDjyXtiJIp3hDiTnX9Y/unYeYgXy/7ouA+GkIUESkX8YJrU/Do8Avurk7S8ZSfWN1XTnPoMtXXw8+Fcf+M/b3qvkREkiZecPUBHg/+3JW0oylP8bqv7Ir+sftH/tovgDnPFwwpdV8iIkkTL7g2OucWO+cWAxuSeUApIVb3Vb0OnPOUr+e+DE+fFPt71X2JiJSpeMH1lpmNMrORwLhkHlBKKGr6/FUToMmVvp50L2yJumWZui8RkTIV77YmbzrnOjjn/gHsk+RjSi2xui/LgiODxXp//cZf+xWLui8RkVJXnJUzDijzo0hlRU2fv/BVaHa9r8f3LrjyhrovEZFSF2t1+FOj/rQB9iqH40pNsYYQzeDwjr5e8zMMOeHv36fOS0Sk1MTquOpG/akDvJbUIwqLWN1XhxfhxN6+fvcW2PiHr9V5iYiUmgqFNzjnXiiPAwmdvO4LYGsQSGZwaHsY29Xf6yte9zX9IWh5a/zJHyIiEldmrA5f1mJ1X+c/Cyfd6esP+udv17JRIiIJUXCVhnjT5w89zz/+NMU//vp9wec1hCgiUmIKrtIWq/u6ZKx/fP40mHRP7O9T9yUiUiwKrtIWq/vKWzaq2/uwZrGv572sZaNERLaDgqssFe6+atSD85/z9afPaNkoEZHtoOAqS9taOqrzJDiuu69f6QC/zM9/Tt2XiEhcCq7ykpWdf+Fy/ebw0rm+/mNZwf3UfYmIFKDgSoZYEzaiNesJPWb5enBz+GRw/nOaPi8iUoCCKxmKWm0eoGpN/3jJWPjqP75e/lXBfRRiIiIKrqQrqvuqexhc8a6vXzgLPnw09n46DyYiGUrBlWxFrTYP+V9fNQG+D26HFj15ozB1XyKSQRRc5amoIcRd94dO7/j6pXNg/B2x91P3JSIZRMGVKuJ1X1nBOsjdP4Q/V/h6/mhwLvbrqPsSkTSn4EoVRXVf1evCec/4+oP+8OLZsfdT9yUiaU7BlYqKmsDRbTo0aO3rt66HtUtj76fuS0TSkIIrFRXVfWVXguN7+rpSNRjS3Nfrfi24n6bPi0gaUnCluqK6rzZ9octUXw86BibeFXs/DSGKSJpQcKW64ly8XDPHP3aeAhvW+HrOsPghpe5LREJMwRUmRXVfu+wDZw/09ezn/QXMsWgIUURCTMEVJsXpvvJ0ngTg07ruAAAWMklEQVQNTvX1G9fC6kWx99MQooiEjIIrrIrqvrIrQrPrfb3DLjC0pa/XLon/muq+RCQEFFxhVZylo/K0vh+unuHrwc3h7Rtj76fuS0RCQMGVDoozhLjTHv7x6plQsaqv374R1iyOvb+6LxFJUQqudFNU97VTXT+FHqBCFRjSwterFxbcT92XiKQoBVe6KckQ4mn/5zswgKGt/CSOWNR9iUgKUXCls2INIdb1jz1mwY67+/q922Ddb/n7aPq8iKQQBVemKKr7qlYLTr7b15s3wJPHBvX6gvspxESknCm4MkVJrgE76zG47C1fP3kcfP5q7P10HkxEykFCwWVm1czsOTMbamYdo7b3MbMRZjbYzPYItmWZ2Ttm1j3Rg5YEFdV9Aex+sH8863H4ZKivJ90Dy7+Kvb+6LxFJkkQ7rvbAaOdcV6Bd1PYtwCZgI7A62HYd8E6C7yeloSQTOPZtBV2m+HrrZhh+nq8XzSi4n4YQRSRJEg2uekDehUDR40V9nXOXAZOBK8zsUMCArxN8PyltxQkxM//Ypi9cP8/XY7rA8Pa+Lnw3Zg0hikgZSjS4luDDq8BrORf5jbUCqA60Bg4BegEXmdmuefuaWRsz679w4cIED0USVpzzYBWq+Mces6FBG18/ewp8OSb2/uq+RKSUJRpcY4AOZvYU8JaZDQMwszuCbTcBLzrnBjjnugD9gVeccyvzXsA5N9451ysnJyfBQ5FSVdQQYsWqcGw3Xx93Dcx43NffvF2wA1P3JSKlrEIi3+ycWwdcGbXp5WB73zj7TwOmJfKekiR53Rf4QeC8EIsVQIeeB4ecCw/Uhin354dYYblbYfpD0PLW4s1uFBGJQdPhpWjFOg8WfH31R3D4hb4efwds/CN/H03gEJFSoOCSkikqxLIqwNFBE/7HL341+lg0hCgi20nBJduvqMkc5z/n10MEGNut4DJS0dR9iUgJKLikdMQbQjzwDP9YqVp+91U4oNR9iUgJKLikdBTVfZ3ZHzq84OunT4Sfpv99H3VeIlIMCi4pffG6r72ChXuPuxbeDG6hsuzz/OfVeYlIMSi4pPQV1X0d/g+49lNfv3w+vH7V3/dR9yUicSi4pGzF674q7uAfe8yGnXN8Peme/OfVfYlIHAouKVtFTZ+vUgNOvsvX61f5x/cfhr9+z99H3ZeIRFFwSfIUNYR49kD/uPxLeOIoX2/6Uxcui0gBCi4pH9taC/GCYXBJsGjvoGPgsxfyn9MQokjGU3BJ+Siq+6rTyD+2fxrmDvf1ggkFF/BV9yWSkRRcUv621X3VbwZXjvf1uH/m3wMM1H2JZCgFl5S/vO4ru+K2F/C9Zibsd5Kv370FNqzJ30fdl0jGUHBJ6ihqBmKFKnD8db7etA6eaurrrZs1gUMkgyi4JDUVdQ7snCfhvGd9PegYmPVs/nMaQhRJawouSX3xzoHVP94/tn0Uvn3b15+9ALlb8vdR9yWSdhRckvqKGkLctyVcOtbXc4fD4Ba+dk5DiCJpSMEl4VLUEOKVE6DlP339Qlv4+eP85zSEKJIWFFwSXrG6LzM45BxfH9IeXgvuxrzoI10DJpImFFwSXkUNITa5CnoEq9D/5xp4trWvNYQoEmoKLkkP8YYQK+3oH3vMhmO7+XrYGbD40/x9NIQoEioKLkk/sbqv7IrQ6AJfN7oARl/u66VzCn6vui+RlKfgkvRT1BDi0Vfm38hy5KXwUnBOTEOIIqGg4JL0Fm8IsXJ1/3jdHDjobF+/1A5+npm/j4YQRVKSgksyR6zuq2JV34GBD7DXr/L1D5M0C1EkRSm4JHMUOQuxs5/EATD+Dhjc3NeFhxBFpFwpuCQzxRtCrLiDf7x6Jpx4h69fagcrvsnfR92XSLlScInE6r6ysqHhmb7e/xQYFtRrl2oCh0g5U3CJFDWEeHxP6P6Rrwc38/cCy6MQE0k6BZdItHghtlNd/3z3j/yyUgBv9IBfv8v/Xp0HE0kKBZdIPLHOg9XYE05/yNfV6/hVOAB+/b7g96r7EikzCi6R4og1hHjSnXDdXF8/fxq8eV3+cxpCFCkzCi6R4og3C7HKTv7x2k+gSg1fj7pMFzKLlCEFl0hJxeq+qtWCUx/wdb0mMDZY0Pf793Qhs0gpU3CJlFSRsxCvy7+QeeI9MLSVr3O3aghRpBQouEQSEW8IMbuSf7x6BjS/0ddDWsD80fn7aAhRZLsouERKS7wLmfPuyHxib/j4KV9/OADW/Zq/n7ovkWJTcImUlqKGEBueCZ0n+3r5VzDwaF//uUJDiCIloOASKQvxhhDzLl4+7xm4OliN48ljYWrf/H0UYiLbpOASKWuxui+AGvX845UTYOWPvp7+L/hrbf4+Og8m8jcKLpGyVtQQ4m4N4Pxnff3r9zDwKF+vX1nwddR9iQAKLpHkKirEzn8WLn/b108cDRN65z+X131t3awAk4ym4BIpL/HOg9Vu6B+7TIXNf/n6P9fA8q99reFDyXAKLpFUEKv7qpkDZz7i6xr14MWzfb3i2/x9NHwoGUjBJZIKihpCPPEOuO4zXw8Prgv731x1X5KRFFwiqaaoBX2vDhbwHXERPB/cViV3q7ovyRgKLpFUFqv7qlrTP/acB0de7uvBzf1yUrr+SzKAgksklW1rCLFCZTj8H74+6U6YMdDX816BLX8pxCRtKbhEwiIvxLIrxl5OqssUX899KepasFVaiUPSjoJLJGziLicV/Ofc6V1oP9TXjzeGsd197XIVYpIWFFwiYRbrHJgZ7N3U19d+DLsd4OsnmsC0fvn7aUaihJSCSyTMippGX70utOjl63ZPwJ/LfT28PXz9Zv5+6r4kRBRcIumiqBDbuym0HeDrQ86FGY/7+sMBsO43DSFKaCi4RNJRUSHW+FLoPMnXv8yHgUf6es1iDSFKylNwiaS7eJM58pz/HHSd7ushLeCNHvnPqfuSFKTgEskk8e4NVrO+f7z2E6hWy9djuviFfTWEKClGwSWSSYoaQtxxdzjlHl/vsi+8cKavf5jkb6eiEJMUoOASyVRFhVir26HHHF9PuAueCC5q3vSnzoNJuVJwiUj8EKu6s3/+6hnQ7klfDzwqf0YiqPuSpEsouMysmpk9Z2ZDzaxj1PY+ZjbCzAab2R5m1tTMnjWz0WZ2ceKHLSJlJtZkDjOof7yvL3wVFs3w9UePwV9rNYQoSZVox9UeGO2c6wq0i9q+BdgEbARWO+dmOueucs5dUGg/EUllsYYQ9zwSOo7w9ZJZ+VPpN6/XklKSFIkGVz1gcVBHD3b3dc5dBkwGrsjbaGY3Ay8k+J4ikixFnQf7x3C4ZIyvBx0Dc4fnP6fzYFJGEg2uJfjwKvBazkV+UlcA1QHMrCewzDn3TvQLmFkbM+u/cOHCBA9FRMpUvOvB6jTyj+2ehDnP+3rmINiwJn8fdV9SihINrjFABzN7CnjLzIYBmNkdwbabgBfN7AzgOqCFmfWOfgHn3HjnXK+cnJwED0VEkiZW97XPCXBVsBrH4k/g8SN8vWG1hhClVFVI5Judc+uAK6M2vRxs71to12XAu4m8l4ikkLzuC/xJgkiIBYMtHV6E1Yv8FPpBx0LzG/O/Ny/ETrjZ7z79IWh5a/yVPUQK0XR4EUlMvCHEvNU4LhoJ37/n60n3wMof8/fReTDZDgouESk9sYYQ92gMl73h680b4NnWvl7+VcHv1RCiFJOCS0RKT1GzEE9/CK7/3NcvtoPXO+c/p/NgUkwKLhEpG/GGECtX9489Zvn1EAGePRXmvZy/j4YQZRsUXCJS9mJ1X1Vrwol3+Pq4q+GLkb6e/pC/sWUedV9SiIJLRMpeUUOIh5wLl73p65UL4Imjfb3mZw0hyt8ouEQkuYq6sWX7p6Hb+74ecgL85+r85zSEKCi4RKQ8xbux5c57+8ces6DGXr5+6VxYMCF/H3VfGUvBJSLlp6ghxGq18s+DHdwOJt7t66/fgNwtGkLMUAouEUkNRYXYUZ2g+0e+fv9hGNzc138u13mwDKPgEpHUEy/E8s6LdZsOJwfd1xNN4JUO+d+r82BpT8ElIqkt5o0ts+CA03x9w3xo0MbXr3SAZZ/n76fuKy0puEQkPGINIVapAU2u8nX95vDy+b5evSi/+9q6WQGWRhRcIhIeRZ0Ha9YTrp3l66EtYXwwsUPnwNKKgktEwileiFXd2T/f/UPYstHXIy/xj7lbdQ4sDSi4RCT8Yp0Hq1EPznzE1/ud5B8fP8J3W3nUfYWSgktE0kusIcSjg/vdXjAM1i339Ssd4Ju3NYQYQgouEUkv2zoPtudR0PZRXx94Orz/kK8/fhI2/q4QCwkFl4ikr7wQy64Y44LmK6DLVF//9314vLGvf/+fzoOlOAWXiKS/eF2YmX++4wi4ZIyvn2wKIy/1tbqvlKTgEpHMEi/E6jTyz18/D3Ka+fqp42HWMxpCTDEKLhHJXLFmI1atCcd293Xr++G7d309+T5Yu0QhlgIUXCIiEHs2YoPWcPFrvt6wCp5q6usFE/w1YjoPVi4UXCIiUPSqHG0fhR6zfT21Lzx6qK9X/aTuK8kUXCIihcULsWq1/PNdp8ElY339zMnw6oW++8rdqhBLAgWXiMi2xAux3Q/2z/f8HPY5wdeDm2kyRxIouEREiitWiFXdOX8yx8n35E/mGHUZfD5CIVYGFFwiItsj1ozEA9rkT+bYtxV8McLXoy6Hr99UiJUSBZeISKLirY+Yd1FzTjOY8ZivX+8MX45RiCVAwSUikqi4K3ME9bHd4aqJft96R/vzYADv9IKlczStvoQUXCIipSk6xGIF2nHXQKe3/b5Vd4GRF/t63suw8Q91X8Wg4BIRSYZY58ROutPPSgT4YiQMONR3X2uXaAhxGxRcIiLJFj2cmF3Rb7vsTbj8LV8/1RTGdNW1YXEouEREki3eObHaB/nnr50Fu+zj68HNYcZATeaIouASESlPsUKseh1o+U//fOv7YEmw1NTrnf29wzI8xBRcIiKpIlaINWgNFzzvn9/9UHirp68/eATW/JyRIabgEhFJRbEmczS/IX+h31U/+SWmwF8Xtnl9xkyrV3CJiKS6wteGAbQbBDd86etPh8KjwY0w1yxO++5LwSUikuriTeaoXN0/f+V7flYiwJDmfp3ENB5CVHCJiIRJUTMSr5sLezT29bC2ftHfNBtCVHCJiIRVrBCrths0u94/f/iFMOleX386FDasTovuS8ElIpIOYoXYkZfB1R/553+c4s+DTe8HS2bB1i2hDTEFl4hIuikcYgAdR0Dnyb4efTkMaRHalTkUXCIi6Sz6PNgu+/ptPedBi5t9/fxpsPADH2JbN4ciwBRcIiLpLNYQYnYlOPhs//zhF8LYbr6e83woZiMquEREMkWsEDv6Kj8TEeC7cf7xrevh549TNsQUXCIimSg6xCpU9iF20Sj/XPU6MKazr2c/Bxt/T6kQU3CJiGS6wstLtbo9vwv7/j147HBfL5oBWzeVe4gpuERExIueyJEXYheNgive8/XbN0D/4ELnxZ/6wCqHEFNwiYiIF29Vjt0a+Oev/RQ6vevr16+CoS19vXmDD68krdCh4BIRkb+LtTo95IdYz7nQ6jZfP34ETH8oeYeWtHcSEZFwiu6+8mRVgAPP8PVFo2DlD0k7HAWXiIhsW7whxDx1D4f2Q5N2OBWS9k4iIhJ+eSEGkEt+iCVx9XkFl4iIbJ94IVbGFFwiIpK46BAr67dKyruIiIiUEgWXiIiEioJLRERCRcElIiKhst2TM8ysGjAQ2AJMdc69GmzvAzQE1gD3AcuAQfg5Jz865wYkeMwiIpLBEum42gOjnXNdgXZR27cAm4CNwGqgOTDfOdcDaGxmFRN4TxERyXCJTIevBwTr3hN95Vlf51yumZ0NXIEPr8XBc78Cu+G7MBERkRJLpONagg+vAq/jXOTy6RVA9UL71QJWRr+ImbUxs/4LFy5M4FBERCRTJBJcY4AOZvYU8JaZDQMwszuCbTcBLwIfAoeZ2WPA5865TdEv4pwb75zrlZOTk8ChiIhIptjuoULn3DrgyqhNLwfb+8bY/ZrtfR8REZFomg4vIiKhouASEZFQUXCJiEioKLhERCRUFFwiIhIqCi4REQkVc86V9zEAYGavA4tK4aXql9LrhIE+a/rKpM+rz5qeEvms9Z1z58V7MmWCq7SYWX/nXK/yPo5k0GdNX5n0efVZ01NZftZ0HCocX94HkET6rOkrkz6vPmt6KrPPmnYdl4iIpLd07LhERCSNJXJbk3JlZvsCvYFqzrkLzewGYH8gG782Yh3gIfwtV553zk0rr2NNVPRnBboBj+H/p2O5c+4WMzsYuD3Y9qBz7utyO9hSUPjfNth2G3BE8G+dNp83xs/x2cCpwFbgn0BN0vDnOPisjwNVgZ3xt0CqTvp81rOBs/B3xBgINCJ9fz9Ff9bngXMp699PzrlQ/wFGAJWAYcHXPfA3r7wLOCj4y3qlvI+ztD5roa9HAgYMwf9HXwMYUt7HWdqfF2gKXBb1ddp93uDnOBsYBzwK3Bv826btz3HU4+3BZ0zHz1oz+GU+LPg6nX8/1Yz+77Esfz+ly1DhrsBvQb0I2At/D7DFLv/+YGnFzFoA3zr/E1LdOfeHc24t/gckbZjZDkBH59yLUZvT9fPWAnZ2zt2Av+nqSaT3z/EPZjYWOBZYQHp+1t7AM2TG76fe+JAq899P6RJcK/F3VgbYG3/zyiVAPTNLl88YEfxQnA30CTb9YWbVzWwn4I9yO7CycTRQ28wGA0ebWVPS9/OuApZG1TuSpj/HZrYbUMs5dy4wGmhLmn1WM+uL76Bnkea/n/I+q3Pus2T8fgrtrEIz2xV4EDgFGApswf9QVAGuBuoC/YLtw51zU8rpUBMW47PeBPwHcMCNwH7ALfi2/CHn3JfldKilovDndc49FGwf4fy5kUNJk88b49/2L/y/Zw2gO7AL6flz/DT+nM9m/Pme6/A/z+nyWa8BugCfAPOAHUjf30/Rn3UJ/t+yTH8/hTa4REQkM6VFmyoiIplDwSUiIqGi4BIRkVBRcIkkmZkNM7MqQd1vO75/RDH2se05NpEwCO3KGSLlycw64S8kXQb84pwbFPVcY6ATUBGYCKwGOgMrgEeAI4A7zWw4kBN8z1z8oqS7A5/jL7oeDHwHXIufXfgOfpr8ocFKIk/jL1b+HfjCOTfEzOYDw4G3zewe/Cyv58I881KkMHVcIttvnHPuLqBZoe034MNqBXAUUBt/4elg59xS/PToB5xz30Z9zy/OuduC75sK9ATOwU+Xrhi81mXOuRnAl865fkBH4Bnn3LX4KeYAS5xz/8Jf6LkaeFGhJelGHZfI9lsXPBb+H8BKQH/n3O95G8xsHnCzmb2CX5+usLXB46ag3ghUBi4FxgKfAW8E++Rdw2IxXmstgHPuYzNbCnQzs8Odcy+U8LOJpCwFl0jp+zcwyMxWAF/jw6QpvgtaCswEHjazJ4vxWjPwCyt/hw81gK3BMOAgYICZXYDv0iLM7ET86gW74ldvEEkbugBZRERCRR2XSILM7EKgYfDl+rwlqkSkbKjjEhGRUNGsQhERCRUFl4iIhIqCS0REQuX/AQ3l0JWxxUVRAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 500x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#对损失放大查看\n",
    "cvresult = pd.DataFrame.from_csv('1_nestimators.csv')\n",
    "cvresult = cvresult.iloc[100:]\n",
    "# plot\n",
    "test_means = cvresult['test-mlogloss-mean']\n",
    "test_stds = cvresult['test-mlogloss-std'] \n",
    "        \n",
    "train_means = cvresult['train-mlogloss-mean']\n",
    "train_stds = cvresult['train-mlogloss-std'] \n",
    "\n",
    "x_axis = range(100,cvresult.shape[0]+100)\n",
    "        \n",
    "fig = pyplot.figure(figsize=(10, 10), dpi=50)\n",
    "pyplot.errorbar(x_axis, test_means, yerr=test_stds ,label='Test')\n",
    "pyplot.errorbar(x_axis, train_means, yerr=train_stds ,label='Train')\n",
    "pyplot.title(\"XGBoost n_estimators vs Log Loss\")\n",
    "pyplot.xlabel( 'n_estimators' )\n",
    "pyplot.ylabel( 'Log Loss' )\n",
    "#pyplot.savefig( 'n_estimators_detail.png' )\n",
    "\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由上述可知，初步可根据默认参数确定弱学习器数目为220"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第二步：对树的参数进行调节"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2.1 粗调"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "稀有事件比例计算结果为3.6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'max_depth': range(3, 10, 2), 'min_child_weight': range(1, 6, 2)}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#对树最大深度及最小样本权重和进行调整\n",
    "max_depth = range(3,10,2)\n",
    "min_child_weight = range(1,6,2)\n",
    "param_test2_1 = dict(max_depth=max_depth, min_child_weight=min_child_weight)\n",
    "param_test2_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "h:\\python36\\lib\\site-packages\\sklearn\\model_selection\\_search.py:761: DeprecationWarning: The grid_scores_ attribute was deprecated in version 0.18 in favor of the more elaborate cv_results_ attribute. The grid_scores_ attribute will not be available from 0.20\n",
      "  DeprecationWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "([mean: -0.60221, std: 0.00318, params: {'max_depth': 3, 'min_child_weight': 1},\n",
       "  mean: -0.60259, std: 0.00328, params: {'max_depth': 3, 'min_child_weight': 3},\n",
       "  mean: -0.60249, std: 0.00324, params: {'max_depth': 3, 'min_child_weight': 5},\n",
       "  mean: -0.58874, std: 0.00413, params: {'max_depth': 5, 'min_child_weight': 1},\n",
       "  mean: -0.58963, std: 0.00368, params: {'max_depth': 5, 'min_child_weight': 3},\n",
       "  mean: -0.58945, std: 0.00342, params: {'max_depth': 5, 'min_child_weight': 5},\n",
       "  mean: -0.58914, std: 0.00317, params: {'max_depth': 7, 'min_child_weight': 1},\n",
       "  mean: -0.58937, std: 0.00370, params: {'max_depth': 7, 'min_child_weight': 3},\n",
       "  mean: -0.58880, std: 0.00357, params: {'max_depth': 7, 'min_child_weight': 5},\n",
       "  mean: -0.60226, std: 0.00388, params: {'max_depth': 9, 'min_child_weight': 1},\n",
       "  mean: -0.59922, std: 0.00566, params: {'max_depth': 9, 'min_child_weight': 3},\n",
       "  mean: -0.59578, std: 0.00374, params: {'max_depth': 9, 'min_child_weight': 5}],\n",
       " {'max_depth': 5, 'min_child_weight': 1},\n",
       " -0.5887351903284485)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xgb2_1 = XGBClassifier(\n",
    "        learning_rate =0.1,\n",
    "        n_estimators=220,  #第一轮参数调整得到的n_estimators最优值\n",
    "        max_depth=5,\n",
    "        min_child_weight=1,\n",
    "        gamma=0,\n",
    "        subsample=0.3,\n",
    "        colsample_bytree=0.8,\n",
    "        colsample_bylevel = 0.7,\n",
    "        objective= 'multi:softprob',\n",
    "        seed=3)\n",
    "\n",
    "\n",
    "gsearch2_1 = GridSearchCV(xgb2_1, param_grid = param_test2_1, scoring='neg_log_loss',n_jobs=-1, cv=kfold)\n",
    "gsearch2_1.fit(X_train , y_train)\n",
    "\n",
    "gsearch2_1.grid_scores_, gsearch2_1.best_params_,     gsearch2_1.best_score_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "粗调得到最优参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best: -0.588735 using {'max_depth': 5, 'min_child_weight': 1}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "h:\\python36\\lib\\site-packages\\sklearn\\utils\\deprecation.py:122: FutureWarning: You are accessing a training score ('mean_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n",
      "h:\\python36\\lib\\site-packages\\sklearn\\utils\\deprecation.py:122: FutureWarning: You are accessing a training score ('std_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n",
      "h:\\python36\\lib\\site-packages\\sklearn\\utils\\deprecation.py:122: FutureWarning: You are accessing a training score ('split0_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n",
      "h:\\python36\\lib\\site-packages\\sklearn\\utils\\deprecation.py:122: FutureWarning: You are accessing a training score ('split1_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n",
      "h:\\python36\\lib\\site-packages\\sklearn\\utils\\deprecation.py:122: FutureWarning: You are accessing a training score ('split2_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n",
      "h:\\python36\\lib\\site-packages\\sklearn\\utils\\deprecation.py:122: FutureWarning: You are accessing a training score ('split3_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n",
      "h:\\python36\\lib\\site-packages\\sklearn\\utils\\deprecation.py:122: FutureWarning: You are accessing a training score ('split4_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'Log Loss')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 结果可视化\n",
    "print(\"Best: %f using %s\" % (gsearch2_1.best_score_, gsearch2_1.best_params_))\n",
    "test_means = gsearch2_1.cv_results_[ 'mean_test_score' ]\n",
    "test_stds = gsearch2_1.cv_results_[ 'std_test_score' ]\n",
    "train_means = gsearch2_1.cv_results_[ 'mean_train_score' ]\n",
    "train_stds = gsearch2_1.cv_results_[ 'std_train_score' ]\n",
    "\n",
    "pd.DataFrame(gsearch2_1.cv_results_).to_csv('my_preds_maxdepth_min_child_weights_1.csv')\n",
    "\n",
    "# plot results\n",
    "test_scores = np.array(test_means).reshape(len(max_depth), len(min_child_weight))\n",
    "train_scores = np.array(train_means).reshape(len(max_depth), len(min_child_weight))\n",
    "\n",
    "for i, value in enumerate(max_depth):\n",
    "    pyplot.plot(min_child_weight, -test_scores[i], label= 'test_max_depth:'   + str(value))\n",
    "# for i, value in enumerate(min_child_weight):\n",
    "#     pyplot.plot(max_depth, train_scores[i], label= 'train_min_child_weight:'   + str(value))\n",
    "    \n",
    "pyplot.legend()\n",
    "pyplot.xlabel( 'max_depth' )                                                                                                      \n",
    "pyplot.ylabel( 'Log Loss' )\n",
    "#pyplot.savefig('max_depth_vs_min_child_weght_1.png' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2.2 细调"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'max_depth': [5, 6, 7], 'min_child_weight': [3, 4, 5]}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#重新定义树的参数\n",
    "max_depth = [5,6,7]\n",
    "min_child_weight = [3,4,5]\n",
    "param_test2_2 = dict(max_depth=max_depth, min_child_weight=min_child_weight)\n",
    "param_test2_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "h:\\python36\\lib\\site-packages\\sklearn\\model_selection\\_search.py:761: DeprecationWarning: The grid_scores_ attribute was deprecated in version 0.18 in favor of the more elaborate cv_results_ attribute. The grid_scores_ attribute will not be available from 0.20\n",
      "  DeprecationWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "([mean: -0.58963, std: 0.00368, params: {'max_depth': 5, 'min_child_weight': 3},\n",
       "  mean: -0.58980, std: 0.00360, params: {'max_depth': 5, 'min_child_weight': 4},\n",
       "  mean: -0.58945, std: 0.00342, params: {'max_depth': 5, 'min_child_weight': 5},\n",
       "  mean: -0.58961, std: 0.00368, params: {'max_depth': 6, 'min_child_weight': 3},\n",
       "  mean: -0.58841, std: 0.00287, params: {'max_depth': 6, 'min_child_weight': 4},\n",
       "  mean: -0.58865, std: 0.00309, params: {'max_depth': 6, 'min_child_weight': 5},\n",
       "  mean: -0.58937, std: 0.00370, params: {'max_depth': 7, 'min_child_weight': 3},\n",
       "  mean: -0.58920, std: 0.00443, params: {'max_depth': 7, 'min_child_weight': 4},\n",
       "  mean: -0.58880, std: 0.00357, params: {'max_depth': 7, 'min_child_weight': 5}],\n",
       " {'max_depth': 6, 'min_child_weight': 4},\n",
       " -0.5884133304371247)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#重新进行参数验证\n",
    "xgb2_2 = XGBClassifier(\n",
    "        learning_rate =0.1,\n",
    "        n_estimators=220,  #第一轮参数调整得到的n_estimators最优值\n",
    "        max_depth=5,\n",
    "        min_child_weight=1,\n",
    "        gamma=0,\n",
    "        subsample=0.3,\n",
    "        colsample_bytree=0.8,\n",
    "        colsample_bylevel = 0.7,\n",
    "        objective= 'multi:softprob',\n",
    "        seed=3)\n",
    "\n",
    "\n",
    "gsearch2_2 = GridSearchCV(xgb2_2, param_grid = param_test2_2, scoring='neg_log_loss',n_jobs=-1, cv=kfold)\n",
    "gsearch2_2.fit(X_train , y_train)\n",
    "\n",
    "gsearch2_2.grid_scores_, gsearch2_2.best_params_,     gsearch2_2.best_score_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best: -0.588413 using {'max_depth': 6, 'min_child_weight': 4}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "h:\\python36\\lib\\site-packages\\sklearn\\utils\\deprecation.py:122: FutureWarning: You are accessing a training score ('mean_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n",
      "h:\\python36\\lib\\site-packages\\sklearn\\utils\\deprecation.py:122: FutureWarning: You are accessing a training score ('std_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n",
      "h:\\python36\\lib\\site-packages\\sklearn\\utils\\deprecation.py:122: FutureWarning: You are accessing a training score ('split0_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n",
      "h:\\python36\\lib\\site-packages\\sklearn\\utils\\deprecation.py:122: FutureWarning: You are accessing a training score ('split1_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n",
      "h:\\python36\\lib\\site-packages\\sklearn\\utils\\deprecation.py:122: FutureWarning: You are accessing a training score ('split2_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n",
      "h:\\python36\\lib\\site-packages\\sklearn\\utils\\deprecation.py:122: FutureWarning: You are accessing a training score ('split3_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n",
      "h:\\python36\\lib\\site-packages\\sklearn\\utils\\deprecation.py:122: FutureWarning: You are accessing a training score ('split4_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'- Log Loss')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 对细调结果进行可视化\n",
    "print(\"Best: %f using %s\" % (gsearch2_2.best_score_, gsearch2_2.best_params_))\n",
    "test_means = gsearch2_2.cv_results_[ 'mean_test_score' ]\n",
    "test_stds = gsearch2_2.cv_results_[ 'std_test_score' ]\n",
    "train_means = gsearch2_2.cv_results_[ 'mean_train_score' ]\n",
    "train_stds = gsearch2_2.cv_results_[ 'std_train_score' ]\n",
    "\n",
    "pd.DataFrame(gsearch2_2.cv_results_).to_csv('my_preds_maxdepth_min_child_weights_2.csv')\n",
    "\n",
    "# plot results\n",
    "test_scores = np.array(test_means).reshape(len(min_child_weight), len(max_depth))\n",
    "train_scores = np.array(train_means).reshape(len(min_child_weight), len(max_depth))\n",
    "\n",
    "for i, value in enumerate(min_child_weight):\n",
    "    pyplot.plot(max_depth, test_scores[i], label= 'test_min_child_weight:'   + str(value))\n",
    "for i, value in enumerate(min_child_weight):\n",
    "    pyplot.plot(max_depth, train_scores[i], label= 'train_min_child_weight:'   + str(value))\n",
    "    \n",
    "pyplot.legend()\n",
    "pyplot.xlabel( 'max_depth' )                                                                                                      \n",
    "pyplot.ylabel( '- Log Loss' )\n",
    "#pyplot.savefig( 'max_depth_vs_min_child_weght2.png' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "细调之后，树的最大深度为6，权重设置为4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第三步：再次调整弱分类器的数目"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "logloss of train :\n",
      "0.49610405824707815\n"
     ]
    }
   ],
   "source": [
    "#调整max_depth和min_child_weight之后再次调整n_estimators(6,1)\n",
    "xgb3 = XGBClassifier(\n",
    "        learning_rate =0.1,\n",
    "        n_estimators=300,  #数值大没关系，cv会自动返回合适的n_estimators\n",
    "        max_depth=6,\n",
    "        min_child_weight=4,\n",
    "        gamma=0,\n",
    "        subsample=0.3,\n",
    "        colsample_bytree=0.8,\n",
    "        colsample_bylevel=0.7,\n",
    "        objective= 'multi:softprob',\n",
    "        seed=3)\n",
    "\n",
    "modelfit(xgb3, X_train, y_train, cv_folds = kfold)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "h:\\python36\\lib\\site-packages\\ipykernel_launcher.py:1: FutureWarning: from_csv is deprecated. Please use read_csv(...) instead. Note that some of the default arguments are different, so please refer to the documentation for from_csv when changing your function calls\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "217"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cvresult = pd.DataFrame.from_csv('1_nestimators.csv')\n",
    "cvresult.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#结果可视化\n",
    "cvresult = cvresult.iloc[100:]\n",
    "# plot\n",
    "test_means = cvresult['test-mlogloss-mean']\n",
    "test_stds = cvresult['test-mlogloss-std'] \n",
    "        \n",
    "train_means = cvresult['train-mlogloss-mean']\n",
    "train_stds = cvresult['train-mlogloss-std'] \n",
    "\n",
    "x_axis = range(100,cvresult.shape[0]+100)\n",
    "        \n",
    "fig = pyplot.figure(figsize=(10, 10), dpi=100)\n",
    "pyplot.errorbar(x_axis, test_means, yerr=test_stds ,label='Test')\n",
    "pyplot.errorbar(x_axis, train_means, yerr=train_stds ,label='Train')\n",
    "pyplot.title(\"XGBoost n_estimators vs Log Loss\")\n",
    "pyplot.xlabel( 'n_estimators' )\n",
    "pyplot.ylabel( 'Log Loss' )\n",
    "#pyplot.savefig( 'n_estimators_detail4_2_3_699.png' )\n",
    "\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "重新调整弱学习器的数目为217"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第四步：行列重采样参数调整"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'subsample': [0.3, 0.4, 0.5, 0.6, 0.7, 0.8],\n",
       " 'colsample_bytree': [0.6, 0.7, 0.8, 0.9]}"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "subsample = [i/10.0 for i in range(3,9)]\n",
    "colsample_bytree = [i/10.0 for i in range(6,10)]\n",
    "param_test4 = dict(subsample=subsample, colsample_bytree=colsample_bytree)\n",
    "param_test4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "h:\\python36\\lib\\site-packages\\sklearn\\model_selection\\_search.py:761: DeprecationWarning: The grid_scores_ attribute was deprecated in version 0.18 in favor of the more elaborate cv_results_ attribute. The grid_scores_ attribute will not be available from 0.20\n",
      "  DeprecationWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "([mean: -0.58795, std: 0.00477, params: {'colsample_bytree': 0.6, 'subsample': 0.3},\n",
       "  mean: -0.58548, std: 0.00318, params: {'colsample_bytree': 0.6, 'subsample': 0.4},\n",
       "  mean: -0.58473, std: 0.00387, params: {'colsample_bytree': 0.6, 'subsample': 0.5},\n",
       "  mean: -0.58387, std: 0.00411, params: {'colsample_bytree': 0.6, 'subsample': 0.6},\n",
       "  mean: -0.58221, std: 0.00381, params: {'colsample_bytree': 0.6, 'subsample': 0.7},\n",
       "  mean: -0.58154, std: 0.00364, params: {'colsample_bytree': 0.6, 'subsample': 0.8},\n",
       "  mean: -0.58840, std: 0.00284, params: {'colsample_bytree': 0.7, 'subsample': 0.3},\n",
       "  mean: -0.58540, std: 0.00400, params: {'colsample_bytree': 0.7, 'subsample': 0.4},\n",
       "  mean: -0.58465, std: 0.00335, params: {'colsample_bytree': 0.7, 'subsample': 0.5},\n",
       "  mean: -0.58282, std: 0.00336, params: {'colsample_bytree': 0.7, 'subsample': 0.6},\n",
       "  mean: -0.58200, std: 0.00299, params: {'colsample_bytree': 0.7, 'subsample': 0.7},\n",
       "  mean: -0.58179, std: 0.00412, params: {'colsample_bytree': 0.7, 'subsample': 0.8},\n",
       "  mean: -0.58838, std: 0.00276, params: {'colsample_bytree': 0.8, 'subsample': 0.3},\n",
       "  mean: -0.58542, std: 0.00382, params: {'colsample_bytree': 0.8, 'subsample': 0.4},\n",
       "  mean: -0.58389, std: 0.00316, params: {'colsample_bytree': 0.8, 'subsample': 0.5},\n",
       "  mean: -0.58288, std: 0.00337, params: {'colsample_bytree': 0.8, 'subsample': 0.6},\n",
       "  mean: -0.58181, std: 0.00335, params: {'colsample_bytree': 0.8, 'subsample': 0.7},\n",
       "  mean: -0.58191, std: 0.00316, params: {'colsample_bytree': 0.8, 'subsample': 0.8},\n",
       "  mean: -0.58787, std: 0.00348, params: {'colsample_bytree': 0.9, 'subsample': 0.3},\n",
       "  mean: -0.58611, std: 0.00396, params: {'colsample_bytree': 0.9, 'subsample': 0.4},\n",
       "  mean: -0.58515, std: 0.00467, params: {'colsample_bytree': 0.9, 'subsample': 0.5},\n",
       "  mean: -0.58288, std: 0.00414, params: {'colsample_bytree': 0.9, 'subsample': 0.6},\n",
       "  mean: -0.58222, std: 0.00392, params: {'colsample_bytree': 0.9, 'subsample': 0.7},\n",
       "  mean: -0.58193, std: 0.00408, params: {'colsample_bytree': 0.9, 'subsample': 0.8}],\n",
       " {'colsample_bytree': 0.6, 'subsample': 0.8},\n",
       " -0.5815372184298553)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xgb4 = XGBClassifier(\n",
    "        learning_rate =0.1,\n",
    "        n_estimators=217,  #第二轮参数调整得到的n_estimators最优值\n",
    "        max_depth=6,\n",
    "        min_child_weight=4,\n",
    "        gamma=0,\n",
    "        subsample=0.3,\n",
    "        colsample_bytree=0.8,\n",
    "        colsample_bylevel = 0.7,\n",
    "        objective= 'multi:softprob',\n",
    "        seed=3)\n",
    "\n",
    "\n",
    "gsearch4 = GridSearchCV(xgb4, param_grid = param_test4, scoring='neg_log_loss',n_jobs=-1, cv=kfold)\n",
    "gsearch4.fit(X_train , y_train)\n",
    "\n",
    "gsearch4.grid_scores_, gsearch4.best_params_,     gsearch4.best_score_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best: -0.581537 using {'colsample_bytree': 0.6, 'subsample': 0.8}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "h:\\python36\\lib\\site-packages\\sklearn\\utils\\deprecation.py:122: FutureWarning: You are accessing a training score ('mean_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n",
      "h:\\python36\\lib\\site-packages\\sklearn\\utils\\deprecation.py:122: FutureWarning: You are accessing a training score ('std_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n",
      "h:\\python36\\lib\\site-packages\\sklearn\\utils\\deprecation.py:122: FutureWarning: You are accessing a training score ('split0_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n",
      "h:\\python36\\lib\\site-packages\\sklearn\\utils\\deprecation.py:122: FutureWarning: You are accessing a training score ('split1_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n",
      "h:\\python36\\lib\\site-packages\\sklearn\\utils\\deprecation.py:122: FutureWarning: You are accessing a training score ('split2_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n",
      "h:\\python36\\lib\\site-packages\\sklearn\\utils\\deprecation.py:122: FutureWarning: You are accessing a training score ('split3_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n",
      "h:\\python36\\lib\\site-packages\\sklearn\\utils\\deprecation.py:122: FutureWarning: You are accessing a training score ('split4_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n",
      "  warnings.warn(*warn_args, **warn_kwargs)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'Log Loss')"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# summarize results\n",
    "print(\"Best: %f using %s\" % (gsearch4.best_score_, gsearch4.best_params_))\n",
    "test_means = gsearch4.cv_results_[ 'mean_test_score' ]\n",
    "test_stds = gsearch4.cv_results_[ 'std_test_score' ]\n",
    "train_means = gsearch4.cv_results_[ 'mean_train_score' ]\n",
    "train_stds = gsearch4.cv_results_[ 'std_train_score' ]\n",
    "\n",
    "pd.DataFrame(gsearch4.cv_results_).to_csv('my_preds_subsampleh_colsample_bytree_1.csv')\n",
    "\n",
    "# plot results\n",
    "test_scores = np.array(test_means).reshape(len(colsample_bytree), len(subsample))\n",
    "train_scores = np.array(train_means).reshape(len(colsample_bytree), len(subsample))\n",
    "\n",
    "for i, value in enumerate(colsample_bytree):\n",
    "    pyplot.plot(subsample, -test_scores[i], label= 'test_colsample_bytree:'   + str(value))\n",
    "# for i, value in enumerate(min_child_weight):\n",
    "#     pyplot.plot(max_depth, train_scores[i], label= 'train_min_child_weight:'   + str(value))\n",
    "    \n",
    "pyplot.legend()\n",
    "pyplot.xlabel( 'subsample' )                                                                                                      \n",
    "pyplot.ylabel( 'Log Loss' )\n",
    "#pyplot.savefig( 'subsample_vs_colsample_bytree1.png' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "行列重采样最优参数为 0.8,0.6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第五步：调整正则化参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'reg_alpha': [0.1, 1, 1.5, 2], 'reg_lambda': [0.1, 0.5, 1, 2]}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reg_alpha = [ 0.1,1,1.5,2]    \n",
    "reg_lambda = [0.1,0.5,1,2]      \n",
    "param_test5 = dict(reg_alpha=reg_alpha, reg_lambda=reg_lambda)\n",
    "param_test5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "h:\\python36\\lib\\site-packages\\sklearn\\model_selection\\_search.py:761: DeprecationWarning: The grid_scores_ attribute was deprecated in version 0.18 in favor of the more elaborate cv_results_ attribute. The grid_scores_ attribute will not be available from 0.20\n",
      "  DeprecationWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "([mean: -0.58164, std: 0.00377, params: {'reg_alpha': 0.1, 'reg_lambda': 0.1},\n",
       "  mean: -0.58146, std: 0.00400, params: {'reg_alpha': 0.1, 'reg_lambda': 0.5},\n",
       "  mean: -0.58153, std: 0.00365, params: {'reg_alpha': 0.1, 'reg_lambda': 1},\n",
       "  mean: -0.58177, std: 0.00342, params: {'reg_alpha': 0.1, 'reg_lambda': 2},\n",
       "  mean: -0.58153, std: 0.00367, params: {'reg_alpha': 1, 'reg_lambda': 0.1},\n",
       "  mean: -0.58156, std: 0.00309, params: {'reg_alpha': 1, 'reg_lambda': 0.5},\n",
       "  mean: -0.58121, std: 0.00323, params: {'reg_alpha': 1, 'reg_lambda': 1},\n",
       "  mean: -0.58151, std: 0.00333, params: {'reg_alpha': 1, 'reg_lambda': 2},\n",
       "  mean: -0.58175, std: 0.00359, params: {'reg_alpha': 1.5, 'reg_lambda': 0.1},\n",
       "  mean: -0.58135, std: 0.00366, params: {'reg_alpha': 1.5, 'reg_lambda': 0.5},\n",
       "  mean: -0.58125, std: 0.00342, params: {'reg_alpha': 1.5, 'reg_lambda': 1},\n",
       "  mean: -0.58172, std: 0.00339, params: {'reg_alpha': 1.5, 'reg_lambda': 2},\n",
       "  mean: -0.58180, std: 0.00345, params: {'reg_alpha': 2, 'reg_lambda': 0.1},\n",
       "  mean: -0.58148, std: 0.00334, params: {'reg_alpha': 2, 'reg_lambda': 0.5},\n",
       "  mean: -0.58188, std: 0.00298, params: {'reg_alpha': 2, 'reg_lambda': 1},\n",
       "  mean: -0.58189, std: 0.00337, params: {'reg_alpha': 2, 'reg_lambda': 2}],\n",
       " {'reg_alpha': 1, 'reg_lambda': 1},\n",
       " -0.5812077676431455)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xgb5 = XGBClassifier(\n",
    "        learning_rate =0.1,\n",
    "        n_estimators=217,  #第二轮参数调整得到的n_estimators最优值\n",
    "        max_depth=6,\n",
    "        min_child_weight=4,\n",
    "        gamma=0,\n",
    "        subsample=0.8,\n",
    "        colsample_bytree=0.6,\n",
    "        colsample_bylevel = 0.7,\n",
    "        objective= 'multi:softprob',\n",
    "        seed=3)\n",
    "\n",
    "\n",
    "gsearch5 = GridSearchCV(xgb5, param_grid = param_test5, scoring='neg_log_loss',n_jobs=-1, cv=kfold)\n",
    "gsearch5.fit(X_train , y_train)\n",
    "\n",
    "gsearch5.grid_scores_, gsearch5.best_params_,     gsearch5.best_score_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第六步：模型预测"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=0.7,\n",
       "       colsample_bytree=0.6, gamma=0, learning_rate=0.1, max_delta_step=0,\n",
       "       max_depth=6, min_child_weight=4, missing=None, n_estimators=217,\n",
       "       n_jobs=1, nthread=None, objective='multi:softprob', random_state=0,\n",
       "       reg_alpha=1, reg_lambda=1, scale_pos_weight=1, seed=3, silent=True,\n",
       "       subsample=0.8)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#设置最优正则化参数\n",
    "xgb5.set_params(reg_alpha=1)\n",
    "xgb5.set_params(reg_lambda=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=0.7,\n",
       "       colsample_bytree=0.6, gamma=0, learning_rate=0.1, max_delta_step=0,\n",
       "       max_depth=6, min_child_weight=4, missing=None, n_estimators=217,\n",
       "       n_jobs=1, nthread=None, objective='multi:softprob', random_state=0,\n",
       "       reg_alpha=1, reg_lambda=1, scale_pos_weight=1, seed=3, silent=True,\n",
       "       subsample=0.8)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#模型拟合\n",
    "xgb5.fit(X_train, y_train, eval_metric='mlogloss')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "#测试数组转换\n",
    "test=np.array(test)\n",
    "#test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "h:\\python36\\lib\\site-packages\\sklearn\\preprocessing\\label.py:151: DeprecationWarning: The truth value of an empty array is ambiguous. Returning False, but in future this will result in an error. Use `array.size > 0` to check that an array is not empty.\n",
      "  if diff:\n"
     ]
    }
   ],
   "source": [
    "#预测\n",
    "y_test = xgb5.predict(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 1, 2, ..., 2, 1, 2], dtype=int64)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    2\n",
       "1    1\n",
       "2    2\n",
       "3    2\n",
       "4    2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_test=pd.Series(y_test)\n",
    "y_test.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "#保存\n",
    "y_test.to_csv(\"submition.csv\",index_label=\"interest_level\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
